import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import 'package_info_service.dart';
import 'storage_service.dart';
import 'dio_service.dart';
import 'permission_service.dart';
import 'user_service.dart';
import '../routers/route_service.dart';

/// 服务定位器 - 统一管理所有GetX服务的注册和初始化
class ServiceLocator {
  /// 初始化所有服务
  static Future<void> init() async {
    debugPrint('🚀 开始初始化服务...');
    
    try {
      // 1. 注册应用包信息服务（基础服务）
      debugPrint('📦 注册应用包信息服务...');
      Get.put<PackageInfoService>(PackageInfoService(), permanent: true);
      await Get.find<PackageInfoService>().onInit();
      
      // 2. 注册存储服务（基础设施层）
      debugPrint('💾 注册存储服务...');
      Get.put<StorageService>(StorageService(), permanent: true);
      await Get.find<StorageService>().onInit();
      
      // 3. 注册网络服务（基础设施层，依赖存储服务）
      debugPrint('🌐 注册网络服务...');
      Get.put<DioService>(DioService(), permanent: true);
      await Get.find<DioService>().onInit();
      
      // 4. 注册权限服务（基础设施层，系统权限管理）
      debugPrint('🔐 注册权限服务...');
      Get.put<PermissionService>(PermissionService(), permanent: true);
      Get.find<PermissionService>().onInit();
      
      // 5. 注册路由服务（基础设施层，路由管理）
      debugPrint('🧭 注册路由服务...');
      Get.put<RouteService>(RouteService(), permanent: true);
      
      // 6. 注册用户服务（业务层，依赖存储服务和网络服务）
      debugPrint('👤 注册用户服务...');
      Get.put<UserService>(UserService(), permanent: true);
      await Get.find<UserService>().onInit();
      
      // TODO: 在这里添加其他业务服务
      
      // 4. 注册用户服务（依赖存储和网络服务）
      // Get.put<UserService>(UserService(), permanent: true);
      
      // 5. 注册主题服务
      // Get.put<ThemeService>(ThemeService(), permanent: true);
      
      debugPrint('✅ 所有服务初始化完成');
      
      // 打印服务注册状态（仅在调试模式下）
      if (kDebugMode) {
        _printServiceStatus();
      }
      
    } catch (e) {
      debugPrint('❌ 服务初始化失败: $e');
      rethrow;
    }
  }
  
  // 服务便捷访问方法（可选，也可以直接使用 Get.find<T>()）
  static PackageInfoService get packageInfo => Get.find<PackageInfoService>();
  static StorageService get storage => Get.find<StorageService>();
  static DioService get network => Get.find<DioService>();
  static PermissionService get permission => Get.find<PermissionService>();
  static RouteService get route => Get.find<RouteService>();
  static UserService get user => Get.find<UserService>();
  
  // TODO: 添加其他服务的获取方法
  // static DioService get network => Get.find<DioService>();
  // static UserService get user => Get.find<UserService>();
  // static ThemeService get theme => Get.find<ThemeService>();
  
  /// 检查服务是否已注册
  static bool isServiceRegistered<T>() {
    return Get.isRegistered<T>();
  }
  
  /// 获取服务统计信息
  static Map<String, dynamic> getServiceStats() {
    return {
      'registeredServices': [
        if (Get.isRegistered<PackageInfoService>()) 'PackageInfoService',
        if (Get.isRegistered<StorageService>()) 'StorageService',
        if (Get.isRegistered<DioService>()) 'DioService',
        if (Get.isRegistered<PermissionService>()) 'PermissionService',
        if (Get.isRegistered<RouteService>()) 'RouteService',
        if (Get.isRegistered<UserService>()) 'UserService',
        // TODO: 添加其他服务检查
        // if (Get.isRegistered<ThemeService>()) 'ThemeService',
      ],
      'totalServices': _getRegisteredServiceCount(),
      'initTime': DateTime.now().toIso8601String(),
    };
  }
  
  /// 获取已注册服务数量
  static int _getRegisteredServiceCount() {
    int count = 0;
    if (Get.isRegistered<PackageInfoService>()) count++;
    if (Get.isRegistered<StorageService>()) count++;
    if (Get.isRegistered<DioService>()) count++;
    if (Get.isRegistered<PermissionService>()) count++;
    if (Get.isRegistered<RouteService>()) count++;
    if (Get.isRegistered<UserService>()) count++;
    // TODO: 添加其他服务计数
    // if (Get.isRegistered<ThemeService>()) count++;
    return count;
  }
  
  /// 打印服务注册状态（调试用）
  static void _printServiceStatus() {
    debugPrint('==================== 服务状态 ====================');
    
    // 检查应用包信息服务
    if (Get.isRegistered<PackageInfoService>()) {
      debugPrint('✅ PackageInfoService: 已注册');
    } else {
      debugPrint('❌ PackageInfoService: 未注册');
    }
    
    // 检查存储服务
    if (Get.isRegistered<StorageService>()) {
      debugPrint('✅ StorageService: 已注册');
    } else {
      debugPrint('❌ StorageService: 未注册');
    }
    
    // 检查网络服务
    if (Get.isRegistered<DioService>()) {
      debugPrint('✅ DioService: 已注册');
    } else {
      debugPrint('❌ DioService: 未注册');
    }
    
    // 检查权限服务
    if (Get.isRegistered<PermissionService>()) {
      debugPrint('✅ PermissionService: 已注册');
    } else {
      debugPrint('❌ PermissionService: 未注册');
    }
    
    // 检查路由服务
    if (Get.isRegistered<RouteService>()) {
      debugPrint('✅ RouteService: 已注册');
    } else {
      debugPrint('❌ RouteService: 未注册');
    }
    
    // 检查用户服务
    if (Get.isRegistered<UserService>()) {
      debugPrint('✅ UserService: 已注册');
    } else {
      debugPrint('❌ UserService: 未注册');
    }
    
    // TODO: 检查其他服务
    
    debugPrint('总计: ${_getRegisteredServiceCount()} 个服务已注册');
    debugPrint('================================================');
  }
  
  /// 重新初始化服务（谨慎使用）
  static Future<void> reinit() async {
    debugPrint('🔄 重新初始化服务...');
    
    try {
      // 清理现有服务
      dispose();
      
      // 重新初始化
      await init();
      
      debugPrint('✅ 服务重新初始化完成');
    } catch (e) {
      debugPrint('❌ 服务重新初始化失败: $e');
      rethrow;
    }
  }
  
  /// 清理所有服务（应用退出时调用）
  static void dispose() {
    debugPrint('🧹 清理所有服务...');
    
    try {
      // 清理应用包信息服务
      if (Get.isRegistered<PackageInfoService>()) {
        Get.delete<PackageInfoService>();
        debugPrint('🧹 PackageInfoService 已清理');
      }
      
      // 清理存储服务
      if (Get.isRegistered<StorageService>()) {
        Get.delete<StorageService>();
        debugPrint('🧹 StorageService 已清理');
      }
      
      // 清理网络服务
      if (Get.isRegistered<DioService>()) {
        Get.delete<DioService>();
        debugPrint('🧹 DioService 已清理');
      }
      
      // 清理权限服务
      if (Get.isRegistered<PermissionService>()) {
        Get.delete<PermissionService>();
        debugPrint('🧹 PermissionService 已清理');
      }
      
      // 清理路由服务
      if (Get.isRegistered<RouteService>()) {
        Get.delete<RouteService>();
        debugPrint('🧹 RouteService 已清理');
      }
      
      // 清理用户服务
      if (Get.isRegistered<UserService>()) {
        Get.delete<UserService>();
        debugPrint('🧹 UserService 已清理');
      }
      
      // TODO: 清理其他服务
      
      debugPrint('✅ 所有服务已清理');
    } catch (e) {
      debugPrint('❌ 服务清理失败: $e');
    }
  }
  
}
